// 1. 创建一个基础Promise示例，模拟异步操作（50%成功概率）
// Promise构造函数接收一个执行器函数，该函数有两个参数：resolve(成功回调)和reject(失败回调)
const promise = new Promise((resolve, reject) => {
    // 使用setTimeout模拟异步操作（如网络请求、文件读写等），1秒后执行
    setTimeout(() => {
        // 生成随机数，50%概率大于0.5
        const success = Math.random() > 0.5;
        if (success) {
            // 成功时调用resolve，将Promise状态改为fulfilled，并传递成功结果
            resolve("操作成功！");
        } else {
            // 失败时调用reject，将Promise状态改为rejected，并传递错误信息
            reject(new Error("操作失败！"));
        }
    }, 1000);
});

// 2. 第一种处理Promise的方式：then方法同时指定成功和失败回调
promise
    .then(
        (value) => {
            console.log("成功：", value); // 当Promise状态为fulfilled时执行
        },
        (reason) => {
            console.log("失败：", reason.message); // 当Promise状态为rejected时执行
        }
    );

// 3. 第二种处理方式：then处理成功，catch捕获失败（更推荐）
// catch本质上是.then(null, rejectionHandler)的语法糖
// 优点：能捕获上游所有then中可能抛出的错误，而不仅仅是初始Promise的错误
promise
    .then((value) => {
        console.log("成功：", value);
    })
    .catch((reason) => {
        console.log("失败：", reason.message);
    });

// 4. 第三种处理方式：添加finally，无论成功/失败都会执行
// finally不接收参数，通常用于清理操作（如关闭加载动画、释放资源等）
promise
    .then((value) => {
        console.log("成功：", value);
    })
    .catch((reason) => {
        console.log("失败：", reason.message);
    })
    .finally(() => {
        console.log("操作结束（无论成功/失败）");
    });

// 5. Promise.resolve()：快速创建一个已成功的Promise
const p1 = Promise.resolve("成功");
p1.then(value => console.log(value)); // 直接执行then的成功回调，输出：成功

// 6. Promise.reject()：快速创建一个已失败的Promise
const p2 = Promise.reject(new Error("失败"));
p2.catch(reason => console.log(reason.message)); // 直接执行catch，输出：失败

// 7. Promise.all()：等待所有Promise完成（全部成功才成功，有一个失败则整体失败）
const p3 = Promise.resolve(3); // 立即成功
const p4 = new Promise(resolve => setTimeout(() => resolve(4), 1000)); // 1秒后成功
const p5 = Promise.resolve(5); // 立即成功

Promise.all([p3, p4, p5])
    .then(values => console.log(values)) // 1秒后输出：[3, 4, 5]（等待所有完成）
    .catch(reason => console.log(reason)); // 若有一个失败则执行

// 8. Promise.allSettled()：等待所有Promise完成（无论成功失败，都返回所有结果）
// 适用于需要知道所有异步操作结果的场景
const p6 = Promise.resolve(6); // 成功
const p7 = Promise.reject(new Error("7 失败")); // 失败

Promise.allSettled([p6, p7])
    .then(results => {
        // 输出：[{status: "fulfilled", value: 6}, {status: "rejected", reason: Error}]
        console.log(results);
    });

// 9. Promise.race()：返回第一个完成的Promise（无论成功或失败）
// 适用于超时控制等场景
const request = new Promise(resolve => setTimeout(() => resolve("请求成功"), 1000)); // 1秒成功
const timeout = new Promise((_, reject) => setTimeout(() => reject(new Error("超时")), 500)); // 0.5秒失败

Promise.race([request, timeout])
    .then(value => console.log(value)) // 若request先完成则执行
    .catch(reason => console.log(reason.message)); // 这里timeout先完成，输出：超时

// 10. Promise.any()：返回第一个成功的Promise（所有失败则返回AggregateError）
// 与race的区别：只关注第一个成功的，忽略失败的，直到所有都失败
const p8 = Promise.reject(new Error("8 失败")); // 失败
const p9 = new Promise(resolve => setTimeout(() => resolve(9), 500)); // 0.5秒成功
const p10 = Promise.reject(new Error("10 失败")); // 失败

Promise.any([p8, p9, p10])
    .then(value => console.log(value)) // p9先成功，输出：9
    .catch(err => {
        console.log(err instanceof AggregateError); // 若所有失败，这里为true
        console.log(err.errors); // 所有失败原因的数组
    });

// 11. Promise链式调用：按顺序执行异步任务
// 模拟异步操作：接收任务名和延迟时间，返回Promise
const asyncTask = (name, delay) => {
    return new Promise(resolve => {
        setTimeout(() => {
            console.log(`任务 ${name} 完成`);
            resolve(name); // 将结果传递给下一个任务
        }, delay);
    });
};

// 链式调用：任务1→任务2→任务3（按顺序执行，前一个完成才执行后一个）
asyncTask("1", 1000) // 第一个任务：1秒完成
    .then(result => {
        console.log("上一个结果：", result); // 输出：上一个结果：1
        return asyncTask("2", 500); // 返回新的Promise，进入下一个then
    })
    .then(result => {
        console.log("上一个结果：", result); // 输出：上一个结果：2
        return asyncTask("3", 800); // 返回第三个任务的Promise
    })
    .then(result => {
        console.log("最终结果：", result); // 输出：最终结果：3
    });

// 12. Promise错误处理与恢复
Promise.resolve(1) // 初始成功，值为1
    .then(value => {
        throw new Error("手动出错"); // 抛出错误，Promise状态变为rejected
        return value + 1; // 此行不会执行
    })
    .then(value => console.log("这里不会执行")) // 上一步出错，此then跳过
    .catch(reason => {
        console.log("捕获错误：", reason.message); // 输出：捕获错误：手动出错
        return 100; // 返回新值，Promise状态转为fulfilled，后续then可继续执行
    })
    .then(value => console.log("恢复执行：", value)); // 输出：恢复执行：100（从错误中恢复）